﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Text;

/*
 * Parse 方法: 识别 JSON 的基本结构（对象或数组）并调用相应的解析方法。
 * ParseObject 和 ParseArray 方法: 解析 JSON 对象和数组。
 * ParseValue 方法: 解析各种 JSON 值，包括字符串、数字、布尔值和 null。
 * ParseString 方法: 解析 JSON 字符串，处理转义字符。
 * ParseNumber 方法: 解析 JSON 数字。
 * ParseBoolean 和 ParseNull 方法: 解析布尔值和 null。
 * SkipWhitespace 方法: 跳过 JSON 字符串中的空格字符。
 */

namespace 代码编辑控件
{
    // 定义 JsonKeyValue 类
    public class JsonKeyValue
    {
        public string Key;  // JSON 键
        public object Value; // JSON 值
    }

    /// <summary>
    /// SimpleJsonParser用于解析 JSON 字符串
    /// </summary>
    public class SimpleJsonParser
    {
        private readonly string _json; // 存储待解析的 JSON 字符串
        private int _index; // 当前解析的字符索引

        // 构造函数，接收 JSON 字符串并初始化索引
        public SimpleJsonParser(string json)
        {
            _json = json;
            _index = 0;
        }

        // 解析入口方法，根据当前字符决定解析对象还是数组
        public object Parse()
        {
            SkipWhitespace(); // 跳过空白字符
            char currentChar = Peek(); // 查看当前字符

            // 判断当前字符，决定是解析对象还是数组
            if (currentChar == '{')
            {
                return ParseObject(); // 解析 JSON 对象
            }
            else if (currentChar == '[')
            {
                return ParseArray(); // 解析 JSON 数组
            }

            throw new FormatException("Invalid JSON format."); // 格式错误
        }

        // 数据格式化
        public static string FormatJson(string json)
        {
            StringBuilder formattedJson = new StringBuilder();
            int indentLevel = 0;
            bool insideString = false;

            for (int i = 0; i < json.Length; i++)
            {
                char currentChar = json[i];

                // 检查当前字符是否是引号（字符串的开始或结束）
                if (currentChar == '\"')
                {
                    insideString = !insideString; // 切换字符串内部状态
                }

                // 如果当前字符是开始的花括号或方括号，并且不在字符串内部，则增加缩进
                if (!insideString && (currentChar == '{' || currentChar == '['))
                {
                    formattedJson.Append(currentChar);
                    formattedJson.AppendLine(); // 换行
                    indentLevel++; // 增加缩进级别
                    formattedJson.Append(new string(' ', indentLevel * 4)); // 添加缩进
                    continue;
                }

                // 如果当前字符是结束的花括号或方括号，并且不在字符串内部，则减少缩进
                if (!insideString && (currentChar == '}' || currentChar == ']'))
                {
                    formattedJson.AppendLine(); // 换行
                    indentLevel--; // 减少缩进级别
                    formattedJson.Append(new string(' ', indentLevel * 4)); // 添加缩进
                    formattedJson.Append(currentChar);
                    continue;
                }

                // 如果当前字符是逗号并且不在字符串内部，则换行
                if (!insideString && currentChar == ',')
                {
                    formattedJson.Append(currentChar);
                    formattedJson.AppendLine(); // 换行
                    formattedJson.Append(new string(' ', indentLevel * 4)); // 添加缩进
                    continue;
                }

                // 其他字符直接添加到结果中
                formattedJson.Append(currentChar);
            }

            return formattedJson.ToString();
        }

        // 封装集合
        public List<JsonKeyValue> OutJsonData(object data)
        {
            Dictionary<string, object> dictionary = (Dictionary<string, object>)data;
            // 创建一个列表用于存储键值对
            var keyValueList = new List<JsonKeyValue>();
            // 遍历字典中的每个键值对
            foreach (var kvp in dictionary)
            {
                string key = kvp.Key; // 获取当前键
                object value = kvp.Value; // 获取当前值

                // 将键值对封装到 JsonKeyValue 对象中并添加到列表
                keyValueList.Add(new JsonKeyValue { Key = key, Value = value });

                // 判断值的类型
                if (value is Dictionary<string, object> nestedDict)
                {
                    // 如果值是嵌套字典，递归调用该方法并将结果添加到列表
                    var nestedKeyValueList = OutJsonData(nestedDict);
                    keyValueList.AddRange(nestedKeyValueList);
                }
                else if (value is List<object> list)
                {
                    // 如果值是列表，遍历列表中的每个元素
                    foreach (var item in list)
                    {
                        if (item is Dictionary<string, object> listItemDict)
                        {
                            // 如果列表元素是字典，递归调用并添加结果
                            var listKeyValueList = OutJsonData(listItemDict);
                            keyValueList.AddRange(listKeyValueList);
                        }
                        else
                        {
                            // 将其他类型的元素添加到列表
                            keyValueList.Add(new JsonKeyValue { Key = $"{key}[]", Value = item });
                        }
                    }
                }
            }
            return keyValueList;
        }

        // 解析 JSON 对象
        private Dictionary<string, object> ParseObject()
        {
            var result = new Dictionary<string, object>(); // 创建字典存储解析结果
            _index++; // 跳过 '{'

            while (true)
            {
                SkipWhitespace(); // 跳过空白字符
                if (Peek() == '}') // 检查是否到达对象结束
                {
                    _index++; // 跳过 '}'
                    return result; // 返回解析的对象
                }

                // 解析键（字符串）
                string key = ParseString();
                SkipWhitespace(); // 跳过空白字符
                _index++; // 跳过 ':'
                object value = ParseValue(); // 解析值（可能是对象、数组或基本数据类型）
                result[key] = value; // 将键值对添加到结果字典中

                SkipWhitespace(); // 跳过空白字符
                char currentChar = Peek(); // 查看下一个字符
                if (currentChar == '}') // 如果是 '}'，结束对象
                {
                    _index++; // 跳过 '}'
                    return result; // 返回解析结果
                }
                else if (currentChar == ',') // 如果是 ','，继续解析下一个键值对
                {
                    _index++; // 跳过 ','
                }
                else
                {
                    throw new FormatException("Expected ',' or '}'."); // 格式错误
                }
            }
        }

        // 解析 JSON 数组
        private List<object> ParseArray()
        {
            var result = new List<object>(); // 创建列表存储解析结果
            _index++; // 跳过 '['

            while (true)
            {
                SkipWhitespace(); // 跳过空白字符
                if (Peek() == ']') // 检查是否到达数组结束
                {
                    _index++; // 跳过 ']'
                    return result; // 返回解析的数组
                }

                object value = ParseValue(); // 解析数组元素
                result.Add(value); // 添加元素到数组

                SkipWhitespace(); // 跳过空白字符
                char currentChar = Peek(); // 查看下一个字符
                if (currentChar == ']') // 如果是 ']'，结束数组
                {
                    _index++; // 跳过 ']'
                    return result; // 返回解析结果
                }
                else if (currentChar == ',') // 如果是 ','，继续解析下一个元素
                {
                    _index++; // 跳过 ','
                }
                else
                {
                    throw new FormatException("Expected ',' or ']'."); // 格式错误
                }
            }
        }

        // 解析 JSON 值，可以是字符串、数字、布尔值、对象或数组
        private object ParseValue()
        {
            SkipWhitespace(); // 跳过空白字符
            char currentChar = Peek(); // 查看当前字符

            // 根据当前字符类型解析不同的值
            if (currentChar == '"') // 字符串
            {
                return ParseString();
            }
            else if (char.IsDigit(currentChar) || currentChar == '-') // 数字
            {
                return ParseNumber();
            }
            else if (currentChar == 't' || currentChar == 'f') // 布尔值
            {
                return ParseBoolean();
            }
            else if (currentChar == 'n') // null
            {
                ParseNull();
                return null; // 返回 null
            }
            else if (currentChar == '{') // 对象
            {
                return ParseObject();
            }
            else if (currentChar == '[') // 数组
            {
                return ParseArray();
            }

            throw new FormatException("Invalid JSON value."); // 格式错误
        }

        // 解析 JSON 字符串
        private string ParseString()
        {
            _index++; // 跳过开头的 '"'
            int startIndex = _index; // 记录字符串起始位置

            while (_index < _json.Length)
            {
                char currentChar = _json[_index];
                if (currentChar == '"') // 遇到结束符 '"'
                {
                    string result = _json.Substring(startIndex, _index - startIndex); // 提取字符串
                    _index++; // 跳过结束的 '"'
                    return result; // 返回解析的字符串
                }
                else if (currentChar == '\\') // 处理转义字符
                {
                    _index++; // 跳过转义符
                }

                _index++; // 继续移动索引
            }

            throw new FormatException("Unterminated string."); // 字符串未终止
        }

        // 解析 JSON 数字
        private double ParseNumber()
        {
            int startIndex = _index; // 记录数字起始位置

            // 继续解析字符，直到遇到非数字、非小数点的字符
            while (_index < _json.Length && (char.IsDigit(_json[_index]) || _json[_index] == '.' || _json[_index] == '-'))
            {
                _index++;
            }

            string numberString = _json.Substring(startIndex, _index - startIndex); // 提取数字字符串
            return double.Parse(numberString, CultureInfo.InvariantCulture); // 解析为 double 类型
        }

        // 解析 JSON 布尔值
        private bool ParseBoolean()
        {
            Debug.WriteLine((StringComparison)_index);
            if (_json.StartsWith("true", (StringComparison)_index)) // 检查是否为 true
            {
                _index += 4; // 跳过 "true"
                return true; // 返回 true
            }
            else if (_json.StartsWith("false", (StringComparison)_index)) // 检查是否为 false
            {
                _index += 5; // 跳过 "false"
                return false; // 返回 false
            }

            throw new FormatException("Invalid boolean value."); // 格式错误
        }

        // 解析 JSON null 值
        private void ParseNull()
        {
            if (_json.StartsWith("null", (StringComparison)_index)) // 正确的参数类型
            {
                _index += 4; // 跳过 "null"
                return; // 返回
            }

            throw new FormatException("Invalid null value."); // 格式错误
        }

        // 查看当前字符而不移动索引
        private char Peek()
        {
            if (_index < _json.Length)
            {
                return _json[_index]; // 返回当前字符
            }
            throw new IndexOutOfRangeException("End of JSON string."); // 索引越界
        }

        // 跳过空白字符
        private void SkipWhitespace()
        {
            while (_index < _json.Length && char.IsWhiteSpace(_json[_index])) // 判断是否是空白字符
            {
                _index++; // 移动索引
            }
        }
    }
}
